/**
 * 验证搜索参数
 * @param {Object} params - 原始参数
 * @returns {Object} 验证后的参数
 */
export function validateSearchParams(params) {
    const validated = {
        search: null,
        type: null,
        page: 1,
        limit: 12,
        userId: null
    }

    // 验证搜索关键词
    if (params.search && typeof params.search === 'string') {
        const trimmed = params.search.trim()
        if (trimmed.length > 0 && trimmed.length <= 100) {
            validated.search = trimmed
        }
    }

    // 验证产品类型
    const validTypes = ['all', 'website', 'app']
    if (params.type && validTypes.includes(params.type)) {
        validated.type = params.type === 'all' ? null : params.type
    } else {
        validated.type = null
    }

    // 验证页码
    const page = parseInt(params.page)
    if (!isNaN(page) && page > 0 && page <= 1000) {
        validated.page = page
    }

    // 验证每页数量
    const limit = parseInt(params.limit)
    if (!isNaN(limit) && limit > 0 && limit <= 50) {
        validated.limit = limit
    }

    // 验证用户ID
    if (params.userId && typeof params.userId === 'string') {
        const trimmed = params.userId.trim()
        if (trimmed.length > 0) {
            validated.userId = trimmed
        }
    }

    return validated
}

/**
 * 验证产品表单数据
 * @param {Object} data - 表单数据
 * @returns {Object} 验证结果
 */
export function validateProductForm(data) {
    const errors = []

    // 验证标题
    if (!data.title || typeof data.title !== 'string') {
        errors.push('标题是必填项')
    } else if (data.title.trim().length === 0) {
        errors.push('标题不能为空')
    } else if (data.title.trim().length > 100) {
        errors.push('标题长度不能超过100个字符')
    }

    // 验证描述
    if (data.description && typeof data.description === 'string') {
        if (data.description.length > 1000) {
            errors.push('描述长度不能超过1000个字符')
        }
    }

    // 验证产品类型
    const validTypes = ['website', 'app']
    if (!data.type || !validTypes.includes(data.type)) {
        errors.push('产品类型必须是 website 或 app')
    }

    // 验证URL格式
    if (data.url) {
        try {
            new URL(data.url)
        } catch {
            errors.push('URL格式不正确')
        }
    }

    // 验证缩略图URL格式
    if (data.thumbnail_url) {
        try {
            new URL(data.thumbnail_url)
        } catch {
            errors.push('缩略图URL格式不正确')
        }
    }

    // 验证文件路径
    if (data.file_path && typeof data.file_path === 'string') {
        if (data.file_path.length > 500) {
            errors.push('文件路径长度不能超过500个字符')
        }
    }

    return {
        isValid: errors.length === 0,
        errors
    }
}

/**
 * 清理和格式化产品数据
 * @param {Object} data - 原始数据
 * @returns {Object} 清理后的数据
 */
export function sanitizeProductData(data) {
    const sanitized = {}

    // 清理标题
    if (data.title) {
        sanitized.title = data.title.toString().trim()
    }

    // 清理描述
    if (data.description) {
        sanitized.description = data.description.toString().trim()
        if (sanitized.description === '') {
            sanitized.description = null
        }
    }

    // 设置产品类型
    if (data.type) {
        sanitized.type = data.type.toString().toLowerCase()
    }

    // 清理URL
    if (data.url) {
        sanitized.url = data.url.toString().trim()
        if (sanitized.url === '') {
            sanitized.url = null
        }
    }

    // 清理缩略图URL
    if (data.thumbnail_url) {
        sanitized.thumbnail_url = data.thumbnail_url.toString().trim()
        if (sanitized.thumbnail_url === '') {
            sanitized.thumbnail_url = null
        }
    }

    // 清理文件路径
    if (data.file_path) {
        sanitized.file_path = data.file_path.toString().trim()
        if (sanitized.file_path === '') {
            sanitized.file_path = null
        }
    }

    // 清理用户ID
    if (data.userId) {
        sanitized.user_id = data.userId.toString().trim()
        if (sanitized.user_id === '') {
            sanitized.user_id = null
        }
    }

    // 设置创建时间
    sanitized.created_at = new Date().toISOString()

    return sanitized
}

/**
 * 验证产品ID格式
 * @param {string} id - 产品ID
 * @returns {boolean} 是否有效
 */
export function validateProductId(id) {
    if (!id || typeof id !== 'string') {
        return false
    }

    // UUID格式验证
    const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i
    return uuidRegex.test(id)
}

/**
 * 验证文件类型
 * @param {File} file - 文件对象
 * @param {Array} allowedTypes - 允许的文件类型
 * @returns {Object} 验证结果
 */
export function validateFileType(file, allowedTypes = []) {
    if (!file || !(file instanceof File)) {
        return {
            isValid: false,
            error: '无效的文件对象'
        }
    }

    if (allowedTypes.length > 0 && !allowedTypes.includes(file.type)) {
        return {
            isValid: false,
            error: `不支持的文件类型: ${file.type}`
        }
    }

    return {
        isValid: true,
        error: null
    }
}

/**
 * 验证文件大小
 * @param {File} file - 文件对象
 * @param {number} maxSize - 最大文件大小（字节）
 * @returns {Object} 验证结果
 */
export function validateFileSize(file, maxSize) {
    if (!file || !(file instanceof File)) {
        return {
            isValid: false,
            error: '无效的文件对象'
        }
    }

    if (file.size > maxSize) {
        const maxSizeMB = (maxSize / 1024 / 1024).toFixed(1)
        const fileSizeMB = (file.size / 1024 / 1024).toFixed(1)
        return {
            isValid: false,
            error: `文件大小 ${fileSizeMB}MB 超过限制 ${maxSizeMB}MB`
        }
    }

    return {
        isValid: true,
        error: null
    }
}/**

 * 验证用户表单数据
 * @param {Object} data - 用户数据
 * @returns {Object} 验证结果 { isValid, errors }
 */
export function validateUserForm(data) {
    const errors = []

    // 验证用户名
    if (!data.username || typeof data.username !== 'string') {
        errors.push('用户名是必填项')
    } else {
        const username = data.username.trim()
        if (username.length < 3) {
            errors.push('用户名不能少于3个字符')
        } else if (username.length > 50) {
            errors.push('用户名不能超过50个字符')
        } else if (!/^[a-zA-Z0-9_]+$/.test(username)) {
            errors.push('用户名只能包含字母、数字和下划线')
        }
    }

    // 验证邮箱
    if (!data.email || typeof data.email !== 'string') {
        errors.push('邮箱是必填项')
    } else {
        const email = data.email.trim()
        const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/
        if (!emailRegex.test(email)) {
            errors.push('请输入有效的邮箱地址')
        } else if (email.length > 255) {
            errors.push('邮箱地址不能超过255个字符')
        }
    }

    // 验证密码
    if (!data.password || typeof data.password !== 'string') {
        errors.push('密码是必填项');
    } else {
        const password = data.password;
        if (password.length < 8) {
            errors.push('密码不能少于8个字符');
        } else if (password.length > 50) {
            errors.push('密码不能超过50个字符');
        } else if (!/^[A-Za-z0-9]+$/.test(password)) {
            errors.push('密码只能包含字母和数字');
        }
    }

    // 验证姓名
    if (!data.full_name || typeof data.full_name !== 'string') {
        errors.push('姓名是必填项')
    } else {
        const fullName = data.full_name.trim()
        if (fullName.length === 0) {
            errors.push('姓名不能为空')
        } else if (fullName.length > 100) {
            errors.push('姓名不能超过100个字符')
        }
    }

    // 验证申请理由
    if (!data.application_reason || typeof data.application_reason !== 'string') {
        errors.push('申请理由是必填项')
    } else {
        const reason = data.application_reason.trim()
        if (reason.length === 0) {
            errors.push('申请理由不能为空')
        } else if (reason.length > 1000) {
            errors.push('申请理由不能超过1000个字符')
        }
    }

    // 验证可选字段
    if (data.organization && typeof data.organization === 'string') {
        if (data.organization.length > 200) {
            errors.push('机构名称不能超过200个字符')
        }
    }

    if (data.department && typeof data.department === 'string') {
        if (data.department.length > 100) {
            errors.push('部门名称不能超过100个字符')
        }
    }

    if (data.phone && typeof data.phone === 'string') {
        const phoneRegex = /^1[3-9]\d{9}$/
        if (!phoneRegex.test(data.phone)) {
            errors.push('请输入有效的手机号码')
        }
    }

    return {
        isValid: errors.length === 0,
        errors
    }
}

/**
 * 清理和标准化用户数据
 * @param {Object} data - 原始用户数据
 * @returns {Object} 清理后的用户数据
 */
export function sanitizeUserData(data) {
    const sanitized = {
        username: data.username?.trim() || '',
        email: data.email?.trim().toLowerCase() || '',
        full_name: data.full_name?.trim() || '',
        application_reason: data.application_reason?.trim() || ''
    }

    // 可选字段
    if (data.organization?.trim()) {
        sanitized.organization = data.organization.trim()
    }

    if (data.department?.trim()) {
        sanitized.department = data.department.trim()
    }

    if (data.phone?.trim()) {
        sanitized.phone = data.phone.trim()
    }

    return sanitized
}